package com.jusha.formulacalculation;

public class TextParser {

    private String text;
    private int pos;
    public String getText() {
        return text;
    }

    public int getPos() {
        return pos;
    }


    public int Remaining() {
        return text.length() - pos;
    }

    public static char NullChar = (char) 0;

    public TextParser() {
        Reset(null);
    }

    public TextParser(String text) {
        Reset(text);
    }

    /**
     * 将当前位置重置为当前文档的开头
     */
    public void Reset() {
        pos = 0;
    }

    /**
     * 设置当前文档并将当前位置重置为其开头
     *
     * @param text
     */
    public void Reset(String text) {
        this.text = (text != null) ? text : null;
        pos = 0;
    }

    /**
     * 指示当前位置是否位于当前文档的末尾
     *
     * @return
     */
    public boolean endOfText() {
        return pos >= text.length();
    }

    /**
     * 返回当前位置的字符，如果在结尾则返回null
     *
     * @return
     */
    public char Peek() {
        return Peek(0);
    }

    /**
     * 返回下一个位置的字符，如果在结尾则返回null
     *
     * @param ahead
     * @return
     */
    public char Peek(int ahead) {
        int aPos = (pos + ahead);
        if (aPos < text.length())
            return text.charAt(aPos);
        return NullChar;
    }

    /**
     * 从指定开始位置到结尾截取子字符串
     *
     * @param start
     * @return
     */
    public String Extract(int start) {
        return Extract(start, text.length());
    }

    /**
     * 从指定位置截取子字符串
     *
     * @param start
     * @param end
     * @return
     */
    public String Extract(int start, int end) {
        return text.substring(start, end);
    }

    /**
     * 当前位置向前移动一个字符
     */
    public void MoveAhead() {
        MoveAhead(1);
    }

    /**
     * 当前位置向前移动ahead个字符
     *
     * @param ahead
     */
    public void MoveAhead(int ahead) {
        pos = Math.min(pos + ahead, text.length());
    }

    /**
     * 移动到指定字符串的下一个匹配位置
     *
     * @param s          指定字符串
     * @param ignoreCase 是否忽略大小写
     */
    public void MoveTo(String s, boolean ignoreCase) {
        if (ignoreCase)
            pos = text.toLowerCase().indexOf(s.toLowerCase(), pos);
        else
            pos = text.indexOf(s, pos);
        if (pos < 0)
            pos = text.length();
    }

    /**
     * 移动到指定字符串的下一个匹配位置
     *
     * @param s 指定字符串
     */
    public void MoveTo(String s) {
        MoveTo(s, false);
    }

    /**
     * 移动到指定字符的下一个匹配位置
     *
     * @param c
     */
    public void MoveTo(char c) {
        pos = text.indexOf(c, pos);
        if (pos < 0)
            pos = text.length();
    }

    /**
     * 移动到任意指定字符的下一个匹配位置
     *
     * @param chars
     */
    public void MoveTo(char[] chars) {
        char[] targets = text.substring(pos).toCharArray();
        String s = String.valueOf(chars);
        for (int i = 0; i < targets.length; i++) {
            if (s.indexOf(targets[i]) > -1) {
                pos += i;
                return;
            }
        }
        pos = text.length();
    }

    /**
     * 向后移动到指定字符外的第一个匹配的字符
     *
     * @param chars
     */
    public void MovePast(char[] chars) {
        while (IsInArray(Peek(), chars))
            MoveAhead();
    }


    /**
     * 检查字符是否在数组中
     *
     * @param c
     * @param chars
     * @return
     */
    protected Boolean IsInArray(char c, char[] chars) {
        for (char ch : chars) {
            if (c == ch)
                return true;
        }
        return false;
    }

    /// <summary>
    /// Moves the current position to the first character that is part of a newline
    /// </summary>
    public void MoveToEndOfLine() {
        char c = Peek();
        while (c != '\r' && c != '\n' && !endOfText()) {
            MoveAhead();
            c = Peek();
        }
    }

    /**
     * 移动当前位置到下一个非空白符
     */
    public void MovePastWhitespace() {
        while (Character.isWhitespace(Peek()))
            MoveAhead();
    }
}
